type go/types.Chan

51 uses

	go/types (current package)
		builtins.go#L178: 		case *Slice, *Chan:
		builtins.go#L196: 				case *Array, *Slice, *Chan:
		builtins.go#L253: 			uch, _ := u.(*Chan)
		builtins.go#L503: 		case *Map, *Chan:
		chan.go#L11: type Chan struct {
		chan.go#L27: func NewChan(dir ChanDir, elem Type) *Chan {
		chan.go#L28: 	return &Chan{dir: dir, elem: elem}
		chan.go#L32: func (c *Chan) Dir() ChanDir { return c.dir }
		chan.go#L35: func (c *Chan) Elem() Type { return c.elem }
		chan.go#L37: func (c *Chan) Underlying() Type { return c }
		chan.go#L38: func (c *Chan) String() string   { return TypeString(c, nil) }
		expr.go#L156: 		ch, _ := u.(*Chan)
		expr.go#L439: 	case *Pointer, *Signature, *Slice, *Map, *Chan:
		infer.go#L622: 	case *Chan:
		infer.go#L774: 	case *Chan:
		mono.go#L236: 		case *Chan:
		operand.go#L253: 	case *Chan:
		operand.go#L391: 	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
		operand.go#L392: 		if Tc, ok := Tu.(*Chan); ok && Identical(Vc.elem, Tc.elem) {
		predicates.go#L176: 	case *Pointer, *Chan:
		predicates.go#L217: 	case *Slice, *Pointer, *Signature, *Map, *Chan:
		predicates.go#L464: 	case *Chan:
		predicates.go#L467: 		if y, ok := y.(*Chan); ok {
		stmt.go#L474: 		uch, _ := u.(*Chan)
		stmt.go#L1057: 	case *Chan:
		subst.go#L235: 	case *Chan:
		subst.go#L238: 			return &Chan{dir: t.dir, elem: elem}
		typestring.go#L268: 	case *Chan:
		typestring.go#L275: 			if c, _ := t.elem.(*Chan); c != nil && c.dir == RecvOnly {
		typexpr.go#L388: 		typ := new(Chan)
		under.go#L122: 	if x, _ := x.(*Chan); x != nil {
		under.go#L123: 		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
		unify.go#L436: 						if yc, _ := under(y).(*Chan); yc != nil && yc.dir != SendRecv {
		unify.go#L727: 	case *Chan:
		unify.go#L731: 		if y, ok := y.(*Chan); ok {

	golang.org/x/exp/apidiff
		compatibility.go#L23: 	case *types.Chan:
		compatibility.go#L24: 		if new, ok := new.(*types.Chan); ok {
		compatibility.go#L47: func (d *differ) checkCompatibleChan(otn *types.TypeName, old, new *types.Chan) {
		correspondence.go#L50: 	case *types.Chan:
		correspondence.go#L51: 		if new, ok := new.(*types.Chan); ok {

	golang.org/x/tools/go/types/objectpath
		objectpath.go#L482: 	case *types.Chan:

	golang.org/x/tools/go/types/typeutil
		map.go#L302: 	case *types.Chan:
		map.go#L465: 	case *types.Chan:

	golang.org/x/tools/internal/gcimporter
		iexport.go#L1046: 	case *types.Chan:

	golang.org/x/tools/internal/typeparams
		coretype.go#L41: 	ch, ok := U.(*types.Chan)
		coretype.go#L49: 		curr, ok := terms[chans].Type().Underlying().(*types.Chan)
		free.go#L108: 	case *types.Chan:

	golang.org/x/tools/internal/typesinternal
		element.go#L84: 		case *types.Chan:
		zerovalue.go#L54: 	case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
		zerovalue.go#L147: 	case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
		zerovalue.go#L260: 	case *types.Chan: